package me.ydq.core.table;

import me.ydq.core.Table;
import me.ydq.misc.Fn;

import java.util.List;
import java.util.function.Supplier;

/**
 * SQL 排序支持，满足各种常用业务排序重载
 */
public interface TableSort<T> {

    Table<T> asc(List<Fn<T, ?>> columns);

    Table<T> desc(List<Fn<T, ?>> columns);

    Table<T> asc(String... columns);

    Table<T> desc(String... columns);

    Table<T> order(String orderByRaw);

    default Table<T> asc(Fn<T, ?> column) {
        return asc(List.of(column));
    }

    default Table<T> asc(boolean condition, Fn<T, ?> column) {
        return condition ? asc(List.of(column)) : (Table<T>) this;
    }

    default Table<T> asc(Fn<T, ?> column1, Fn<T, ?> column2) {
        return asc(List.of(column1, column2));
    }

    default Table<T> asc(Fn<T, ?> column1, Fn<T, ?> column2, Fn<T, ?> column3) {
        return asc(List.of(column1, column2, column3));
    }

    default Table<T> desc(Fn<T, ?> column) {
        return desc(List.of(column));
    }

    default Table<T> desc(boolean condition, Fn<T, ?> column) {
        return condition ? desc(List.of(column)) : (Table<T>) this;
    }

    default Table<T> desc(Fn<T, ?> column1, Fn<T, ?> column2) {
        return desc(List.of(column1, column2));
    }

    default Table<T> desc(Fn<T, ?> column1, Fn<T, ?> column2, Fn<T, ?> column3) {
        return desc(List.of(column1, column2, column3));
    }

    /**
     * 动态排序 满许条件才进行排序（如前段传入了排序参数才进行排序），最后一个参数判断是否启用倒序
     */
    default Table<T> sort(Supplier<Boolean> condition, Fn<T, ?> column, boolean reverse) {
        return sort(Boolean.TRUE.equals(condition.get()), column, reverse);
    }

    default Table<T> sort(boolean condition, Fn<T, ?> column, boolean reverse) {
        return condition ? reverse ? desc(column) : asc(column) : (Table<T>) this;
    }

    /**
     * 动态排序 和 动态排序方向，满许条件才进行排序，排序方向也根据返回值是否倒序
     *
     * @param condition 排序条件，当返回true 则启用排序
     * @param column    排序列
     * @param reverse   是否倒序
     */
    default Table<T> sort(Supplier<Boolean> condition, Fn<T, ?> column, Supplier<Boolean> reverse) {
        return sort(Boolean.TRUE.equals(condition.get()), column, reverse);
    }

    /**
     * 动态排序 和 动态排序方向，满许条件才进行排序，排序方向也根据返回值是否倒序
     *
     * @param condition 排序条件，当返回true 则启用排序
     * @param column    排序列
     * @param reverse   是否倒序
     */
    default Table<T> sort(boolean condition, Fn<T, ?> column, Supplier<Boolean> reverse) {
        return condition ? Boolean.TRUE.equals(reverse.get()) ? desc(column) : asc(column) : (Table<T>) this;
    }

    /**
     * 应对 类似于手写函数排序、 field 等特殊排序，自行处理
     * eg: filed(state,5,1,3,4,2)
     * eg: age > 18
     */
    default Table<T> order(Supplier<Boolean> condition, String orderByRaw) {
        return Boolean.TRUE.equals(condition.get()) ? order(orderByRaw) : (Table<T>) this;
    }

    default Table<T> order(boolean condition, String orderByRaw) {
        return condition ? order(orderByRaw) : (Table<T>) this;
    }

}
